Primul pas în Calculul Cuantic

• Dificultate: Începător
• Timp QPU utilizat: 11s

Bun venit, hackeri! Suntem încântați să te avem la workshop. Scopul principal al acestui hands-on introductiv este să te pregătești pentru călătoria ta cuantică prin: 1) a te ghida cum să instalezi Qiskit, 2) cum să creezi un cont IBM Cloud și să pregătești api_key și crn pentru a folosi un calculator cuantic real, 3) să creezi primul tău Circuit cuantic, 4) să rezolvi un quiz de stări cuantice și 5) să rulezi circuitele pe un calculator cuantic real și să vizualizezi rezultatul.

1. Mai întâi lucrurile esențiale: Qiskit

Ce este Qiskit

Qiskit SDK este un stack software de înaltă performanță, construit pentru a ajuta dezvoltatorii și cercetătorii să valorifice întreaga putere a calculatoarelor cuantice la scară de utilitate și dincolo de aceasta. La baza sa se află Qiskit SDK, un kit de dezvoltare software open source pentru lucrul cu calculatoare cuantice la nivelul circuitelor cuantice extinse. Operatori și primitive. Qiskit SDK permite oricui să obțină performanță optimă de la calculatoare cuantice reale, folosind mediul de calcul preferat.

Dincolo de SDK, Qiskit include și o suită de instrumente și servicii de înaltă performanță, precum Qiskit Runtime Service, care permite calcule optimizate pe calculatoarele cuantice IBM prin cloud, folosind primitive care gestionează atenuarea erorilor. Serviciul Qiskit Transpiler oferă metode heuristice de ultimă generație și metode bazate pe AI, care îmbunătățesc performanța pentru sarcinile comune de optimizare a Circuit-urilor cuantice.

Funcțiile Qiskit, un catalog de servicii IBM și terțe părți, facilitează optimizarea fluxurilor de lucru și valorificarea Qiskit pentru cazuri de utilizare industrială. Indiferent dacă ești un dezvoltator de software cuantic, un experimentator cuantic, un om de știință computațional sau vrei pur și simplu să faci primii pași, cadrul modular și flexibil al Qiskit îți permite să lucrezi la nivelul de abstractizare care se potrivește cel mai bine nevoilor tale.

Qiskit este proiectat pentru extensibilitate și personalizare, astfel încât să poți extrage performanțe de top din industrie și să abordezi noi tipuri de probleme. O bază de cod de înaltă performanță înseamnă că Qiskit SDK funcționează mai rapid, utilizează mai puțină memorie și oferă rezultate mai bune ca niciodată. Qiskit te introduce, de asemenea, într-o vastă comunitate de utilizatori și dezvoltatori care sunt dornici să te primească și să îți răspundă la întrebări. Lansat pentru prima dată în 2019, programul Qiskit advocate este o inițiativă globală, centrată pe comunitate, care recrutează profesioniști și entuziaști ai calculului cuantic din întreaga lume. De-a lungul anilor, advocacy-rii au ajuns să devină lideri recunoscuți în comunitatea cuantică. Vrei să fii următorul lider cuantic? Nu ezita să aplici - here

Instalează Qiskit

Mai întâi, verifică că versiunea de Python folosită în mediul tău este python>=3.10, pentru a te asigura că este compatibilă cu cea mai recentă versiune Qiskit pe care o vom folosi

from platform import python_version

print(python_version())

Dacă nu este cazul, îl poți actualiza folosind instrumentul preferat. Dacă nu ești sigur cum să procedezi, iată câteva opțiuni recomandate:

• MacOS: Homebrew
• Linux: sudo apt-get update

Un ghid detaliat despre cum să actualizezi Python în funcție de sistemul de operare este disponibil aici: How to update Python

Pentru mai multe informații, aruncă o privire la wiki-ul QGSS (Qiskit Global Summer School) 2025: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Poți verifica instalarea rulând celula de mai jos. Dacă ai instalat corect, va returna versiunea de Qiskit.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Depanare

Dacă celula anterioară a generat o eroare, poți opta pentru instalarea Qiskit într-un mediu virtual (sunt sugerate două metode). Dacă nu ai erori, poți ignora această celulă și continua cu următoarea.

Propunem două metode diferite pentru a configura un mediu virtual pentru instalarea Qiskit.

1. Folosind venv, după cum este explicat în ghidul de instalare Qiskit.
2. Folosind conda, după cum este explicat în acest videoclip din seria Coding with Qiskit.

2. Configurează-ți contul IBM Cloud

Pentru a folosi un calculator cuantic real, ai nevoie de un api key - biletul principal de acces în cloud - și de un crn - tokenul care îți va aduce resursele prin configurarea contului tău.

Configurează-ți contul după cum urmează:

1. Accesează IBM Quantum® Platform.
2. Mergi în colțul din dreapta sus (după cum se arată în imaginea de mai sus), creează tokenul tău API și copiază-l într-un loc sigur.
3. În celula următoare, înlocuiește deleteThisAndPasteYourAPIKeyHere cu cheia ta API.
4. Mergi în colțul din stânga jos (după cum se arată în imaginea de mai sus) și creează-ți instanța. Asigură-te că alegi planul deschis.
5. După ce instanța este creată, copiază codul CRN asociat. Este posibil să fie nevoie să reîmprospătezi pagina pentru a vedea instanța.
6. În celula de mai jos, înlocuiește deleteThisAndPasteYourCRNHere cu codul tău CRN.

Consultă acest ghid pentru mai multe detalii despre configurarea contului tău IBM Cloud®.

⚠️ Notă: Tratează cheia ta API ca pe o parolă securizată. Consultă ghidul Cloud setup pentru mai multe informații despre utilizarea cheii API atât în medii sigure, cât și în medii nesigure.

În plus, dacă ești membru al rețelei de parteneri universitari IBM, te rog să folosești adresa de email instituțională pentru IBM ID-ul tău, pentru a beneficia de avantajele de partener.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Primul tău Circuit Cuantic

Circuite cuantice

Unitatea fundamentală a Qiskit este circuitul cuantic (quantum circuit), care este o serie de instrucțiuni pe care un calculator cuantic le poate folosi pentru a lucra cu biți cuantici de informație, cunoscuți și sub numele de qubiți. Acești qubiți au proprietăți speciale care permit calculatoarelor cuantice să abordeze problemele diferit față de laptopul sau iPhone-ul tău. Qiskit evoluează rapid ca tehnologie -- deși poți în continuare să proiectezi manual circuitele cuantice și să decizi cum vrei să ruleze (și există motive bune pentru a face asta), IBM Quantum îți oferă și instrumente care simplifică procesul. De dragul învățării, vom proiecta un Circuit foarte simplu și îl vom rula pe un simulator.

Trecem rapid prin această prezentare generală pentru că, sincer, am putea petrece ore întregi explicând noțiunile de bază ale informației și calculului cuantic. De fapt, IBM Quantum a făcut deja asta, producând un curs scris și o serie de prelegeri video dedicate acestui subiect. Dacă ai nevoie de o recapitulare, verifică-le!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Operații de bază pe Qubiți și Măsurători

Scrierea stărilor unui singur Qubit

Să începem prin a privi un singur Qubit. Principala diferență față de un bit clasic, care poate lua doar valorile 0 și 1, este că un bit cuantic, sau Qubit, poate fi în stările $\vert0\rangle$, $\vert1\rangle$, precum și o combinație liniară a acestor două stări. Această caracteristică este cunoscută sub numele de superpozitie și ne permite să scriem cea mai generală stare a unui Qubit astfel:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Dacă am măsura starea acestui Qubit, am găsi rezultatul $1$ cu probabilitatea $p$ și rezultatul $0$ cu probabilitatea $1-p$. După cum poți vedea, probabilitatea totală este $1$, ceea ce înseamnă că vom măsura fie $0$, fie $1$, fără alte rezultate posibile.

Pe lângă $p$, ai putut observa un alt parametru mai sus. Variabila $\phi$ indică faza cuantică relativă dintre cele două stări $\vert0\rangle$ și $\vert1\rangle$. Așa cum vom descoperi mai târziu, această fază relativă este destul de importantă. Deocamdată, este suficient să notăm că faza cuantică este cea care permite interferența dintre stările cuantice, rezultând în capacitatea noastră de a scrie algoritmi cuantici pentru rezolvarea unor sarcini specifice.

Vizualizarea stărilor cuantice

Vizualizăm stările cuantice pe tot parcursul acestui exercițiu folosind ceea ce este cunoscut ca o qsphere. Iată cum arată qsphere pentru stările $\vert0\rangle$ și respectiv $\vert1\rangle$. Observă că partea de sus a sferei reprezintă starea $\vert0\rangle$, în timp ce partea de jos reprezintă $\vert1\rangle$.

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Poți obține exact aceeași QSphere folosind un Circuit cuantic. Statevectorul folosit aici provine din starea $|0\rangle$. În Qiskit, Qubit-ul este inițializat în starea $|0\rangle$. Încearcă să rulezi circuitul de mai jos și vezi dacă poți obține aceeași QSphere.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Acum să vizualizăm starea $|1\rangle$. Nu ar trebui să fie o surpriză că starea de superpozitie cu faza cuantică $\phi = 0$ și probabilitatea $p = 1/2$ (adică probabilitate egală de a măsura atât 0 cât și 1) este afișată pe qsphere cu două puncte. Totuși, observă că și dimensiunea cercurilor de la cele două puncte este mai mică decât atunci când aveam pur și simplu $\vert0\rangle$ și $\vert1\rangle$ mai sus. Aceasta deoarece dimensiunea cercurilor este proporțională cu probabilitatea de a măsura fiecare stare, care acum este redusă la jumătate.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

În cazul stărilor de superpozitie în care faza cuantică este diferită de zero, qsphere ne permite să vizualizăm acea fază schimbând culoarea petei respective. De exemplu, starea cu $\phi = 90^\circ$ (grade) și probabilitatea $p = 1/2$ este afișată în qsphere mai jos.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Manipularea Qubiților

Qubiții sunt manipulați prin aplicarea de Gate-uri cuantice. Să trecem printr-o prezentare generală a diferitelor Gate-uri pe care le vom considera în exercițiile următoare.

Mai întâi, să descriem cum putem schimba valoarea lui $p$ pentru starea cuantică generală. Pentru aceasta, vom folosi două Gate-uri:

1. Gate-ul $X$: Acest Gate comută între cele două stări $\vert0\rangle$ și $\vert1\rangle$. Această operație este echivalentă cu poarta clasică NOT. Ca rezultat, Gate-ul $X$ este uneori numit poartă bit flip sau NOT. Matematic, Gate-ul $X$ schimbă $p$ în $1-p$, deci în special de la 0 la 1 și invers.

2. Gate-ul $H$: Acest Gate ne permite să trecem de la starea $\vert0\rangle$ la starea $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$. Această stare este cunoscută și ca $\vert+\rangle$. Matematic, aceasta înseamnă trecerea de la $p=0, \phi=0$ la $p=1/2, \phi=0$. Deoarece starea finală a Qubit-ului este o superpozitie de $\vert0\rangle$ și $\vert1\rangle$, Gate-ul Hadamard reprezintă o operație cu adevărat cuantică.

Observă că ambele Gate-uri au schimbat valoarea lui $p$, dar nu și pe cea a lui $\phi$. Din fericire, este destul de ușor să vizualizăm acțiunea acestor Gate-uri uitându-ne la figura de mai jos.

Odată ce avem starea $\vert+\rangle$, putem schimba faza cuantică aplicând mai multe alte Gate-uri. De exemplu, un Gate $S$ adaugă o fază de $90$ de grade la $\phi$, în timp ce Gate-ul $Z$ adaugă o fază de $180$ de grade la $\phi$. Pentru a scădea o fază de $90$ de grade, putem aplica Gate-ul $S^\dagger$, citit ca S-dagger, și scris în mod obișnuit ca sdg. În cele din urmă, există un Gate $Y$ care aplică o secvență de Gate-uri $Z$ și $X$.

Poți experimenta cu Gate-urile $X$, $Y$, $Z$, $H$, $S$ și $S^\dagger$ pentru a te familiariza cu diferitele operații și cu modul în care acestea afectează starea unui Qubit. Pentru aceasta, poți vizita Circuit Composer și lansa widget-ul nostru de Circuit. După ce accesezi Circuit Composer, alege un Gate de aplicat unui Qubit, apoi alege Qubit-ul (în primele exemple, singurul Qubit de ales este Qubit-ul 0). Urmărește cum se schimbă starea corespunzătoare cu fiecare Gate, precum și descrierea acelei stări. De asemenea, va oferi codul care creează Circuit-ul cuantic corespunzător în Qiskit.

Dacă vrei să afli mai multe despre descrierea stărilor cuantice, operatorii Pauli și alte Gate-uri cu un singur Qubit, consultă Quantum Information din Single System al cursului Basics of Quantum Information susținut de John Watrous.

Exerciții practice: Circuit-uri Cuantice Folosind Gate-uri cu un Singur Qubit

Iată patru exerciții mici pentru a atinge diferite stări pe qsphere. Le poți rezolva fie cu Circuit Composer și copiind codul pe care îl oferă în celulele respective pentru a crea Circuit-urile cuantice, fie poți insera direct o combinație din următoarele linii de cod în program pentru a aplica diferitele Gate-uri:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

(0) indică faptul că aplicăm acest Gate Qubit-ului q0, care este primul (și în acest caz singurul) Qubit.

Încearcă să atingi starea indicată pe qsphere în fiecare dintre exercițiile următoare.

i) Să începem prin a efectua un bit flip. Scopul este de a ajunge la starea $\vert1\rangle$ pornind din starea $\vert0\rangle$.

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Acum să creăm o superpozitie. Scopul este de a ajunge la starea $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$.

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Să le combinăm pe cele două. Scopul este de a ajunge la starea $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$.

Poți combina cele două sarcini de mai sus pentru a găsi soluția?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) În final, trecem la numerele complexe. Scopul este de a ajunge la starea $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Quiz Cuantic cu Gate-uri Multi-Qubit

Felicitari! Acum ca ai inteles gate-urile cu un singur Qubit, hai sa ne uitam la gate-urile care opereaza pe mai multi qubiti. Ti se va cere sa rezolvi 4 quiz-uri de stari cuantice combinand gate-uri cu un singur Qubit si gate-uri multi-Qubit. Gate-urile de baza pe doi qubiti sunt:

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Daca doresti sa citesti mai multe despre diferitele gate-uri multi-Qubit si relatiile dintre ele, viziteaza Quantum Information pentru sisteme multiple, din cursul Basics of Quantum Information al lui John.

Retine ca pentru doi qubiti, o stare generala are forma $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$, unde $a$, $b$, $c$ si $d$ sunt numere complexe ale caror valori absolute la patrat dau probabilitatea de a masura starea respectiva; de ex., $|a|^2$ ar fi probabilitatea de a ajunge in starea '0' pe ambii qubiti. Aceasta inseamna ca putem avea acum pana la patru puncte pe qsphere.

Incepem cu gate-ul canonic pe doi qubiti, gate-ul controlled-NOT (cunoscut si ca CNOT sau CX). Aici, ca la toate gate-urile controlate pe doi qubiti, un Qubit este etichetat drept "control", iar celalalt se numeste "tinta". Daca Qubit-ul de control se afla in starea $|0\rangle$, se aplica gate-ul identitate $I$ pe tinta, adica nu se efectueaza nicio operatie. In schimb, daca Qubit-ul de control se afla in starea $|1\rangle$, un X-gate este aplicat pe Qubit-ul tinta. Astfel, cu ambii qubiti in una dintre cele doua stari clasice, $|0\rangle$ sau $|1\rangle$, gate-ul CNOT se limiteaza la operatii clasice.

Aceasta situatie se schimba dramatic atunci cand aplicam mai intai un gate Hadamard pe Qubit-ul de control, aducandu-l in starea de superpozitie $|+\rangle$. Actiunea unui gate CNOT asupra acestei intrari non-clasice poate produce stari puternic intricate intre qubitii de control si cei tinta. Daca Qubit-ul tinta se afla initial in starea $|0\rangle$, starea rezultata este notata cu $|\Phi^+\rangle$ si este una dintre asa-numitele stari Bell.

i) Construieste starea Bell $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$.

Pentru aceasta stare am avea probabilitatea $\frac{1}{2}$ de a masura "00" si probabilitatea $\frac{1}{2}$ de a masura "11". Astfel, rezultatele ambilor qubiti sunt perfect corelate.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Incearca apoi sa creezi starea de qubiti perfect anti-corelati. Observa semnul minus de aici, care indica faza relativa dintre cele doua stari.

ii) Construieste starea Bell $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$.

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Ti se ofera Circuit-ul cuantic descris in functia de mai jos. Schimba starile primului si celui de-al doilea Qubit pentru a obtine acest QSphere.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Scrie un program de la zero care creeaza starea GHZ (pe trei qubiti), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Ruleaza Circuit-ul tau si vezi rezultatul masurat cu un computer cuantic real

Acum ca stim cum sa construim un Circuit cuantic pentru a manipula un statevector de qubiti. Si a venit momentul pentru cea mai captivanta parte: rularea lui si vizualizarea rezultatelor! Aici vom invata modul modern si eficient de a executa circuit-urile folosind Qiskit.

Un pattern Qiskit este un cadru general de descompunere a problemelor specifice unui domeniu si de contextualizare a capacitatilor necesare pe etape. Acest lucru permite compozabilitatea fara efort a noilor capacitati dezvoltate de cercetatorii IBM Quantum (si de altii) si permite un viitor in care sarcinile de calcul cuantic sunt efectuate de o infrastructura de calcul heterogena puternica (CPU/GPU/QPU).

Cei patru pasi ai unui pattern Qiskit sunt:

1. Map problem to quantum circuits and operators
2. Optimize for target hardware
3. Execute on target hardware
4. Post-process results

Tocmai am terminat Step 1: Mapping, construind Circuit-uri cuantice pentru a genera starea cuantica dorita. Acum, hai sa parcurgem pasii ramasi pentru a vedea rezultatele.

Optimizare

Aici vom seta Backend-ul pentru a rula Circuit-urile - poti selecta QPU-ul least busy din grupurile de QPU accesibile, sau poti alege pur si simplu un simulator daca nu mai ai suficient timp GPU ramas. Odata ce alegi un Backend, pass_manager va transpila Circuit-urile tale in seturile de gate-uri native ale Backend-ului ales si le va optimiza pentru a obtine un rezultat mai bun. Poti declara cu usurinta pass_manager folosind generate_preset_pass_manager si setand optimization_level, unde un numar mai mare indica mai multi pasi de optimizare.

Urmatorul pas este captivant - vom rula Circuit-ul cuantic folosind Qiskit Runtime!

Vom face asta folosind cele doua primitive Qiskit:

1. Sampler esantioneaza registrul de iesire din executia unuia sau mai multor Circuit-uri cuantice. Iesirea sa consta in numaratori per masurare per shot.
2. Estimator calculeaza valoarea de asteptare a unuia sau mai multor observabile fata de starile generate de Circuit-ul cuantic. Iesirea sa consta in valorile de asteptare impreuna cu erorile lor standard.

Aici vom folosi Sampler pentru a executa Circuit-urile noastre. Celula de cod de mai jos iti arata cum sa definesti mai intai un Backend si un pass manager pentru acesta. Apoi, va adauga measurement la toate Circuit-urile si va crea un tablou de Circuit-uri cuantice (pub) de transmis Sampler-ului.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Executare

Hai sa executam Circuit-urile noastre. Daca exista o coada de asteptare mare in cloud, afiseaza si salveaza job_id pentru utilizare ulterioara si verifica job_status. Dupa ce vezi ca starea jobului se schimba in Done, recupereaza rezultatul jobului.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Post-procesare

Ultimul pas este sa interpretezi vizualizarea pentru a intelege starile cuantice pe care le-am creat. Inainte de a trasa mai multe grafice, hai sa colectam toate numaratorile din toate Circuit-urile. Apoi vom face 4 grafice, categorizand Circuit-urile.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Starile cu un singur Qubit

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Starile cu un Qubit in Superpozitie

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Starile cu doi Qubiti

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Starile cu trei Qubiti

plot_distribution(counts_all[8], legend=['qc9'])

Provocare suplimentara

Ai gasit zgomot in rezultatele experimentale obtinute pe Backend-ul real? Eliminarea zgomotului qubitilor este unul dintre domeniile active de cercetare. Incearca optiunile variate de atenuare si suprimare a erorilor ale Qiskit Runtime pentru a vedea cum se schimba zgomotul din rezultatele executiei! (Nota) Aceste optiuni necesita mai mult timp QPU.

Informatii suplimentare

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Created by: Sophy Shin

Reviewed by: Nate Earnest-Noble

© IBM Corp., 2025

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.